var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
// 静态属性
// 在课程二的ES6部分1我们成学到什么时静态属性：这些属性存在于类本身上面而不是类的实例上，
// 我们只能通过类.属性名称的方式来调用，而不是在实例上进行调用
var Grid = /** @class */ (function () {
    function Grid(scale) {
        this.scale = scale;
        // console.log(scale);
    }
    Grid.prototype.calculateDuataceFromOrigin = function (point) {
        // console.log(point);
        var xDist = (point.x - Grid.origin.y);
        var yDist = (point.y - Grid.origin.y);
        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
    };
    Grid.origin = { x: 0, y: 0 };
    return Grid;
}());
// 1x scale
var grid1 = new Grid(1.0);
// 5x scale
var grid2 = new Grid(5.0);
// console.log(grid1.calculateDuataceFromOrigin({x:1,y:11}));
// console.log(grid2.calculateDuataceFromOrigin({x:5,y:55}));
// 如果代码中标注处写了this.origin的话是会直接报错的，因为构造函数生成的实例，
// 而实例是不会继承类的静态方法
// 抽象类
// 抽象类作为其他派生类的基类使用
// 它们一般不会直接被实例化
// 不同于接口，抽象类可以包含成员的实现细节
// abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法
// 抽象类中的抽象方法不包含具体实现并且必须在派生类中实现
// 抽象方法的语法与接口方法相似
// 两者都是定义方法签名但不包含方法体
// 然而抽象方法必须包含abstruse关键字
var Department = /** @class */ (function () {
    // 相当于定义了一个公共接口name进行赋值
    function Department(name) {
        this.name = name;
    }
    Department.prototype.printName = function () {
        console.log('Department name:' + this.name);
    };
    return Department;
}());
var AccountingDepartment = /** @class */ (function (_super) {
    __extends(AccountingDepartment, _super);
    function AccountingDepartment() {
        // 在派生类构造函数中必须调用super()
        return _super.call(this, 'Accounting and Auditing') || this;
    }
    AccountingDepartment.prototype.printMeeting = function () {
        console.log('The Accounting Department meets each Monday at 10am');
    };
    AccountingDepartment.prototype.hello = function () {
        // 这个方法不会被继承下去 抽象类与解耦类似， 
        // 因为抽象类中没有定义该名称方法，改成其他名字也是一样
        console.log('你好！世界！');
    };
    return AccountingDepartment;
}(Department));
// 允许创建一个对抽象类型的引用
var department;
// 错误: 不能创建一个抽象类的实例
// department = new Department();
// 允许对一个抽象子类进行实例化和赋值
department = new AccountingDepartment();
console.log(department);
// 继承自父类 输出Department name: Accounting and Auding
department.printName();
// 子类自身自带方法 输出The Accounting Department meets each Monday at 10am.
department.printMeeting();
// 错误：方法在上声明的抽象类中不存在
// department.hello();
// 高级技巧
// 把类当作接口使用
// 因为类可以创建出类型
// 所以你能够在允许使用接口的地方使用类
var Point2 = /** @class */ (function () {
    function Point2() {
    }
    return Point2;
}());
var point3d = { x: 1, y: 2, z: 3 };
console.log(point3d);
